package com.EAIPClub.userdatamanager.service.impl;

import com.EAIPClub.userdatamanager.mapper.UserBaseDataMapper;
import com.EAIPClub.userdatamanager.mapper.UserGroupDataMapper;
import com.EAIPClub.userdatamanager.mapper.UserPrivilegesDataMapper;
import com.EAIPClub.userdatamanager.service.UserDataService;
import com.EAIPClub.userdatamanager.util.ConstantPool;
import com.api.POJO.UserDataManager.Data.User;
import com.api.POJO.UserDataManager.Data.UserGroup;
import com.api.POJO.UserDataManager.Data.UserPrivileges;
import com.api.POJO.UserDataManager.Result.UserDataReturnMsg;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description :用户数据管理模块业务逻辑层接口实现
 * @Author :崔昌赫
 * @Date : 2021/10/10
 */
@Service
@Slf4j
public class UserDataServiceImpl implements UserDataService {

    private UserBaseDataMapper userBaseDataMapper;
    @Autowired
    public void setUserBaseDataMapper(UserBaseDataMapper userBaseDataMapper) {
        this.userBaseDataMapper = userBaseDataMapper;
    }
    private UserPrivilegesDataMapper userPrivilegesDataMapper;
    @Autowired
    public void setUserPrivilegesDataMapper(UserPrivilegesDataMapper userPrivilegesDataMapper) {
        this.userPrivilegesDataMapper = userPrivilegesDataMapper;
    }
    private UserGroupDataMapper userGroupDataMapper;
    @Autowired
    public void setUserGroupDataMapper(UserGroupDataMapper userGroupDataMapper) {
        this.userGroupDataMapper = userGroupDataMapper;
    }
    @Override
    public UserDataReturnMsg findUserAllInfoByUid(String uid) {
        log.info("即将通过uid查找用户所有信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String>Msg = new ArrayList<>();
        User userBaseDataByUid = userBaseDataMapper.findUserBaseDataByUid(uid);
        UserPrivileges userPrivilegesByUid = userPrivilegesDataMapper.findUserUserPrivilegesDataByUid(uid);
        UserGroup userGroupByUid = userGroupDataMapper.findUserGroupDataByUid(uid);
        if(userBaseDataByUid==null) {
            log.warn("用户基本信息未能找到!\n执行操作:通过uid查找用户所有信息\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息未能找到!");
        }
        if (userPrivilegesByUid==null) {
            log.warn("用户权限信息未能找到!\n执行操作:通过uid查找用户所有信息\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户权限信息未能找到!");
        }
        if (userGroupByUid==null) {
            log.warn("用户所属用户组信息未能找到!\n执行操作:通过uid查找用户所有信息\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户所属用户组信息未能找到!");
        }
        log.info("查找到用户基本信息:{}",userBaseDataByUid);
        log.info("查找到用户权限信息:{}",userPrivilegesByUid);
        log.info("查找到用户所属用户组信息:{}",userGroupByUid);
        log.info("查找完毕.");
        returnMsg.setUser(userBaseDataByUid);
        returnMsg.setUserPrivileges(userPrivilegesByUid);
        returnMsg.setUserGroup(userGroupByUid);
        returnMsg.setMsg(Msg);
        log.info("本次业务执行完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg findUserAllInfoByEmail(String email) {
        log.info("即将通过email查找用户所有信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        List<String>Msg = new ArrayList<>();
        log.info("开始通过email查找用户基本信息.");
        if (userBaseDataByEmail==null) {
            returnMsg.setStatus(ConstantPool.ERROR);
            log.info("用户基本信息未能找到!\n执行操作:通过用户email查找用户全部信息\nemail:{}",email);
            Msg.add("用户基本信息未能找到!");
            returnMsg.setMsg(Msg);
            log.warn("查找失败!");
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        UserPrivileges userPrivilegesByUid = userPrivilegesDataMapper.findUserUserPrivilegesDataByUid(userBaseDataByEmail.getUid());
        UserGroup userGroupByUid = userGroupDataMapper.findUserGroupDataByUid(userBaseDataByEmail.getUid());
        if (userPrivilegesByUid==null) {
            log.warn("用户权限信息未能找到!\n执行操作:通过用户email查找用户全部信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户权限信息未能找到!");
        }
        if (userGroupByUid==null){
            log.warn("用户所属组信息未能找到!\n执行操作:通过用户email查找用户全部信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户所属组信息未能找到!");
        }
        log.info("查找到用户基本信息:{}",userBaseDataByEmail);
        log.info("查找到用户权限信息:{}",userPrivilegesByUid);
        log.info("查找到用户所属用户组信息:{}",userGroupByUid);
        log.info("查找完毕.");
        returnMsg.setUser(userBaseDataByEmail);
        returnMsg.setUserPrivileges(userPrivilegesByUid);
        returnMsg.setUserGroup(userGroupByUid);
        returnMsg.setMsg(Msg);
        log.info("本次业务执行完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg findUserBaseInfoByUid(String uid) {
        log.info("即将通过Uid查找用户基本信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        User userBaseDataByUid = userBaseDataMapper.findUserBaseDataByUid(uid);
        List<String> Msg = new ArrayList<>();
        if(userBaseDataByUid==null){
            log.warn("用户基本信息未能找到!\n执行操作:通过uid查找用户基本信息\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
        }
        log.info("查找到用户基本信息:{}",userBaseDataByUid);
        log.info("查找完毕.");
        returnMsg.setUser(userBaseDataByUid);
        returnMsg.setMsg(Msg);
        log.info("本次业务执行完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg findUserBaseInfoByEmail(String email) {
        log.info("即将通过email查找用户基本信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        List<String> Msg = new ArrayList<>();
        if(userBaseDataByEmail==null){
            log.warn("用户基本信息未能找到!\n执行操作:通过email查找用户基本信息\nuid:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
        }
        log.info("查找到用户基本信息:{}",userBaseDataByEmail);
        log.info("查找完毕.");
        returnMsg.setUser(userBaseDataByEmail);
        returnMsg.setMsg(Msg);
        log.info("本次业务执行完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg findUserPrivilegesByUid(String uid) {
        log.info("即将通过uid查找用户权限信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        UserPrivileges userPrivilegesByUid = userPrivilegesDataMapper.findUserUserPrivilegesDataByUid(uid);
        List<String> Msg = new ArrayList<>();
        if(userPrivilegesByUid==null){
            log.warn("用户权限信息查询失败!\n执行操作:通过用户uid查找用户权限\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户权限信息查询失败!");
        }
        log.info("查找到用户权限信息:{}",userPrivilegesByUid);
        log.info("查找完毕.");
        returnMsg.setUserPrivileges(userPrivilegesByUid);
        returnMsg.setMsg(Msg);
        log.info("本次业务执行完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg findUserPrivilegesByEmail(String email) {
        log.info("即将通过email查找用户权限信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        if(userBaseDataByEmail==null){
            log.warn("用户基本信息查询失败!\n执行操作:通过用户email查找用户权限\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
            returnMsg.setMsg(Msg);
            log.warn("查找失败!");
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        UserPrivileges userPrivilegesByUid = userPrivilegesDataMapper.findUserUserPrivilegesDataByUid(userBaseDataByEmail.getUid());
        if(userPrivilegesByUid==null){
            log.warn("用户权限信息查询失败!\n执行操作:通过用户email查找用户权限\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户权限信息查询失败!");
        }
        log.info("查找到用户权限信息:{}",userPrivilegesByUid);
        log.info("查找完毕.");
        returnMsg.setUser(userBaseDataByEmail);
        returnMsg.setUserPrivileges(userPrivilegesByUid);
        returnMsg.setMsg(Msg);
        log.info("本次业务执行完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg findUserGroupByUid(String uid) {
        log.info("即将通过uid查找用户所属用户组信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        UserGroup userGroupByUid = userGroupDataMapper.findUserGroupDataByUid(uid);
        if(userGroupByUid==null){
            log.warn("用户所属用户组信息查询失败!\n执行操作:通过用户uid查找用户所属用户组\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户所属用户组查询失败!");
        }
        log.info("查找到用户所属用户组信息:{}",userGroupByUid);
        log.info("查找完毕.");
        returnMsg.setUserGroup(userGroupByUid);
        returnMsg.setMsg(Msg);
        log.info("本次业务执行完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg findUserGroupByEmail(String email) {
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        if (userBaseDataByEmail==null){
            log.warn("用户基本信息查询失败!\n执行操作:通过用户email查找用户权限\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
            returnMsg.setMsg(Msg);
            log.warn("查找失败!");
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        UserGroup userGroupByUid = userGroupDataMapper.findUserGroupDataByUid(userBaseDataByEmail.getUid());
        if(userGroupByUid==null){
            log.warn("用户所属用户组信息查询失败!\n执行操作:通过用户email查找用户所属用户组\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户所属用户组查询失败!");
        }
        log.info("查找到用户所属用户组信息:{}",userGroupByUid);
        log.info("查找完毕.");
        returnMsg.setUserGroup(userGroupByUid);
        returnMsg.setMsg(Msg);
        log.info("本次业务执行完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg updateUserAllInfoByUid(String uid, User user, UserPrivileges userPrivileges, UserGroup userGroup) {
        log.info("即将开始通过uid更新用户所有信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if(user.getUid()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataUidByUid(user.getUid(), uid)) {
                log.warn("用户基本信息[uid]更新失败!\n执行操作:通过uid更新用户所有信息\nuid:{},user:{},userPrivileges:{},userGroup:{}", uid, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户uid失败!");
            }
        }
        if(user.getEmail()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataEmailByUid(user.getEmail(), user.getUid())) {
                log.warn("用户基本信息[email]更新失败!\n执行操作:通过uid更新用户所有信息\nuid:{},user:{},userPrivileges:{},userGroup:{}", uid, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户email失败!");

            }
        }
        if(user.getPassword()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataPasswordByUid(user.getPassword(), user.getUid())) {
                log.warn("用户基本信息[password]更新失败!\n执行操作:通过uid更新用户所有信息\nuid:{},user:{},userPrivileges:{},userGroup:{}", uid, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户password失败!");
            }
        }
        if(userPrivileges.getUid()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataUidByUid(userPrivileges.getUid(), uid)) {
                log.warn("用户权限信息[uid]更新失败!\n执行操作:通过uid更新用户所有信息\nuid:{},user:{},userPrivileges:{},userGroup:{}", uid, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户权限uid失败!");
            }
        }
        if(userPrivileges.getCodeIde()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeIdeByUid(userPrivileges.getCodeIde(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeIde]更新失败!\n执行操作:通过uid更新用户所有信息\nuid:{},user:{},userPrivileges:{},userGroup:{}", uid, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeIde权限失败!");
            }
        }
        if(userPrivileges.getCodeShell()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeShellByUid(userPrivileges.getCodeShell(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeShell]更新失败!\n执行操作:通过uid更新用户所有信息\nuid:{},user:{},userPrivileges:{},userGroup:{}", uid, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeShell权限失败!");
            }
        }
        if(userPrivileges.getCodeDesktop()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeDesktopByUid(userPrivileges.getCodeDesktop(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeDesktop]更新失败!\n执行操作:通过uid更新用户所有信息\nuid:{},user:{},userPrivileges:{},userGroup:{}", uid, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeDesktop权限失败!");
            }
        }
        if(userGroup.getUid()!=null) {
            if (!userGroupDataMapper.updateUserUidByUid(userGroup.getUid(), uid)) {
                log.warn("用户所属用户组信息[uid]更新失败!\n执行操作:通过uid更新用户所有信息\nuid:{},user:{},userPrivileges:{},userGroup:{}", uid, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户所属用户组uid失败!");
            }
        }
        if(userGroup.getGroupId()!=null) {
            if (!userGroupDataMapper.updateUserGroupDataByUid(userGroup.getGroupId(), userGroup.getUid())) {
                log.warn("用户所属用户组信息[groupid]更新失败!\n执行操作:通过uid更新用户所有信息\nuid:{},user:{},userPrivileges:{},userGroup:{}", uid, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户用户组失败!");
            }
        }
        returnMsg.setMsg(Msg);
        log.info("更新完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg updateUserAllInfoByEmail(String email, User user, UserPrivileges userPrivileges, UserGroup userGroup) {
        log.info("即将开始通过email更新用户所有信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        if(userBaseDataByEmail==null){
            log.warn("用户基本信息查询失败!\n所在操作:通过email更新用户所有信息\nemail:{},user:{},userPrivileges:{},userGroup:{}",email,user,userPrivileges,userGroup);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
            returnMsg.setMsg(Msg);
            log.warn("查找失败!");
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        if(user.getUid()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataUidByUid(user.getUid(), userBaseDataByEmail.getUid())) {
                returnMsg.setStatus(ConstantPool.ERROR);
                log.warn("用户基本信息[uid]更新失败!\n执行操作:通过email更新用户所有信息\nemail:{},user:{},userPrivileges:{},userGroup:{}", email, user, userPrivileges, userGroup);
                Msg.add("更新用户uid失败!");
            }
        }
        if(user.getEmail()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataEmailByUid(user.getEmail(), user.getUid())) {
                log.warn("用户基本信息[email]更新失败!\n执行操作:通过email更新用户所有信息\nemail:{},user:{},userPrivileges:{},userGroup:{}", email, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户email失败!");
            }
        }
        if(user.getPassword()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataPasswordByUid(user.getPassword(), user.getUid())) {
                log.warn("用户基本信息[password]更新失败!\n执行操作:通过email更新用户基本信息\nemail:{},user:{},userPrivileges:{},userGroup:{}", email, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户password失败!");
            }
        }
        if(userPrivileges.getUid()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataUidByUid(userPrivileges.getUid(), userBaseDataByEmail.getUid())) {
                log.warn("用户权限信息[uid]更新失败!\n执行操作:通过email更新用户所有信息\nemail:{},user:{},userPrivileges:{},userGroup:{}", email, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户权限uid失败!");
            }
        }
        if(userPrivileges.getCodeIde()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeIdeByUid(userPrivileges.getCodeIde(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeIde]更新失败!\n执行操作:通过email更新用户所有信息\nemail:{},user:{},userPrivileges:{},userGroup:{}", email, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeIde权限失败!");
            }
        }
        if(userPrivileges.getCodeShell()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeDesktopByUid(userPrivileges.getCodeShell(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeShell]更新失败!\n执行操作:通过email更新用户所有信息\nemail:{},user:{},userPrivileges:{},userGroup:{}", email, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeShell权限失败!");
            }
        }
        if(userPrivileges.getCodeDesktop()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeDesktopByUid(userPrivileges.getCodeDesktop(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeDesktop]更新失败!\n执行操作:通过email更新用户所有信息\nemail:{},user:{},userPrivileges:{},userGroup:{}", email, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeDesktop权限失败!");
            }
        }
        if(userGroup.getUid()!=null) {
            if (!userGroupDataMapper.updateUserUidByUid(userGroup.getUid(), userBaseDataByEmail.getUid())) {
                log.warn("用户所属用户组信息[uid]更新失败!\n执行操作:通过email更新用户所有信息\nemail:{},user:{},userPrivileges:{},userGroup:{}", email, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户所属用户组uid失败!");
            }
        }
        if(userGroup.getGroupId()!=null) {
            if (!userGroupDataMapper.updateUserGroupDataByUid(userGroup.getGroupId(), userGroup.getUid())) {
                log.warn("用户所属用户组信息[groupid]更新失败!\n执行操作:通过email更新用户所有信息\nemail:{},user:{},userPrivileges:{},userGroup:{}", email, user, userPrivileges, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户用户组失败!");
            }
        }
        log.info("更新完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg updateUserBaseInfoByUid(String uid, User user) {
        log.info("即将开始通过uid更新用户基本信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if(user.getUid()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataUidByUid(user.getUid(), uid)) {
                log.warn("用户基本信息[uid]更新失败!\n执行操作:通过uid更新用户基本信息\nuid:{},user:{}", uid, user);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户uid失败!");
            }
        }
        if(user.getEmail()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataEmailByUid(user.getEmail(), user.getUid())) {
                log.warn("用户基本信息[email]更新失败!\n执行操作:通过uid更新用户基本信息\nuid:{},user:{}", uid, user);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户email失败!");
            }
        }
        if(user.getPassword()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataPasswordByUid(user.getPassword(), user.getUid())) {
                log.warn("用户基本信息[password]更新失败!\n执行操作:通过uid更新用户基本信息\nuid:{},user:{}", uid, user);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户password失败!");
            }
        }
        log.info("更新完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg updateUserBaseInfoByEmail(String email, User user) {
        log.info("即将开始通过用户email更新用户基本信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        if(userBaseDataByEmail==null){
            log.warn("用户基本信息查询失败!\n所在操作:通过email更新用户信息\nemail:{},user:{}",email,user);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
            log.warn("查找失败!");
            returnMsg.setMsg(Msg);
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        if (user.getUid()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataUidByUid(user.getUid(), userBaseDataByEmail.getUid())) {
                log.warn("用户基本信息[uid]更新失败!\n执行操作:通过uid更新用户基本信息\nemail:{},user:{}", email, user);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户uid失败!");
            }
        }
        if(user.getEmail()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataEmailByUid(user.getEmail(), user.getUid())) {
                log.warn("用户基本信息[email]更新失败!\n执行操作:通过uid更新用户基本信息\nemail:{},user:{}", email, user);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户email失败!");
            }
        }
        if(user.getPassword()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataPasswordByUid(user.getPassword(), user.getUid())) {
                log.warn("用户基本信息[password]更新失败!\n执行操作:通过uid更新用户基本信息\nemail:{},user:{}", email, user);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户password失败!");
            }
        }
        returnMsg.setMsg(Msg);
        log.info("更新完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg updateUserPrivilegesByUid(String uid, UserPrivileges userPrivileges) {
        log.info("即将开始通过用户uid更新用户权限信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if(userPrivileges.getUid()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataUidByUid(userPrivileges.getUid(), uid)) {
                log.warn("用户权限信息[uid]更新失败!\n执行操作:通过uid更新用户权限信息\nuid:{},userPrivileges:{}", uid, userPrivileges);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户权限uid失败!");
            }
        }
        if(userPrivileges.getCodeIde()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeIdeByUid(userPrivileges.getCodeIde(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeIde]更新失败!\n执行操作:通过uid更新用户权限信息\nuid:{},userPrivileges:{}", uid, userPrivileges);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeIde权限失败!");
            }
        }
        if(userPrivileges.getCodeShell()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeShellByUid(userPrivileges.getCodeShell(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeShell]更新失败!\n执行操作:通过uid更新用户权限信息\nuid:{},userPrivileges:{}", uid, userPrivileges);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeShell权限失败!");
            }
        }
        if(userPrivileges.getCodeDesktop()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeDesktopByUid(userPrivileges.getCodeDesktop(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeDesktop]更新失败!\n执行操作:通过uid更新用户权限信息\nuid:{},userPrivileges:{}", uid, userPrivileges);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeDesktop权限失败!");
            }
        }
        returnMsg.setMsg(Msg);
        log.info("更新完毕.");
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg updateUserPrivilegesByEmail(String email, UserPrivileges userPrivileges) {
        log.info("即将开始通过用户email更新用户权限信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        if(userBaseDataByEmail==null){
            log.warn("用户基本信息查询失败!\n所在操作:通过email更新用户权限信息\nemail:{},userPrivileges:{}",email,userPrivileges);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
            log.warn("查找失败!");
            returnMsg.setMsg(Msg);
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        if(userPrivileges.getUid()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataUidByUid(userPrivileges.getUid(), userBaseDataByEmail.getUid())) {
                log.warn("用户权限信息[uid]更新失败!\n执行操作:通过email更新用户权限信息\nemail:{},userPrivileges:{}", email, userPrivileges);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户权限uid失败!");
            }
        }
        if(userPrivileges.getCodeIde()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeIdeByUid(userPrivileges.getCodeIde(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeIde]更新失败!\n执行操作:通过email更新用户权限信息\nemail:{},userPrivileges:{}", email, userPrivileges);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeIde权限失败!");
            }
        }
        if(userPrivileges.getCodeShell()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeShellByUid(userPrivileges.getCodeShell(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeShell]更新失败!\n执行操作:通过email更新用户权限信息\nemail:{},userPrivileges:{}", email, userPrivileges);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeShell权限失败!");
            }
        }
        if(userPrivileges.getCodeDesktop()!=null) {
            if (!userPrivilegesDataMapper.updateUserPrivilegesDataCodeDesktopByUid(userPrivileges.getCodeDesktop(), userPrivileges.getUid())) {
                log.warn("用户权限信息[CodeDesktop]更新失败!\n执行操作:通过email更新用户权限信息\nemail:{},userPrivileges:{}", email, userPrivileges);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户CodeDesktop权限失败!");
            }
        }
        log.info("更新完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg updateUserGroupByUid(String uid, UserGroup userGroup) {
        log.info("即将开始通过用户uid更新用户所属用户组信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if(userGroup.getUid()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataUidByUid(userGroup.getUid(), uid)) {
                log.warn("用户所属用户组信息[uid]更新失败!\n执行操作:通过uid更新用户权限信息\nuid:{},userGroup:{}", uid, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户所属用户组uid失败!");
            }
        }
        if(userGroup.getGroupId()!=null) {
            if (!userGroupDataMapper.updateUserGroupDataByUid(userGroup.getGroupId(), userGroup.getUid())) {
                log.warn("用户所属用户组信息[groupid]更新失败!\n执行操作:通过uid更新用户权限信息\nuid:{},userGroup:{}", uid, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户用户组失败!");
            }
        }
        log.info("更新完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg updateUserGroupByEmail(String email, UserGroup userGroup) {
        log.info("即将开始通过用户uid更新用户所属用户组信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        if(userBaseDataByEmail==null){
            log.warn("用户基本信息查询失败!\n所在操作:通过email更新用户所属用户组信息\nemail:{},userGroup:{}",email,userGroup);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
            log.warn("查找失败!");
            returnMsg.setMsg(Msg);
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        if(userGroup.getUid()!=null) {
            if (!userBaseDataMapper.updateUserBaseDataUidByUid(userGroup.getUid(), userBaseDataByEmail.getUid())) {
                log.warn("用户所属用户组信息[uid]更新失败!\n执行操作:通过email更新用户权限信息\nemail:{},userGroup:{}", email, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户所属用户组uid失败!");
            }
        }
        if(userGroup.getGroupId()!=null) {
            if (!userGroupDataMapper.updateUserGroupDataByUid(userGroup.getGroupId(), userGroup.getUid())) {
                log.warn("用户所属用户组信息[groupid]更新失败!\n执行操作:通过email更新用户权限信息\nemail:{},userGroup:{}", email, userGroup);
                returnMsg.setStatus(ConstantPool.ERROR);
                Msg.add("更新用户用户组失败!");
            }
        }
        log.info("更新完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg addUserAllInfo(User user, UserPrivileges userPrivileges, UserGroup userGroup) {
        log.info("即将开始添加用户所有信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if (!userBaseDataMapper.addUserIntoUserBaseData(user)) {
            log.warn("添加用户基本信息失败!\n执行操作:添加用户所有信息\nuser:{},userPrivileges:{}，userGroup:{}",user,userPrivileges,userGroup);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("添加用户基本信息失败!");
        }
        if (!userPrivilegesDataMapper.addUserIntoUserPrivilegesData(userPrivileges)) {
            log.warn("添加用户权限信息失败!\n执行操作:添加用户所有信息\nuser:{},userPrivileges:{}，userGroup:{}",user,userPrivileges,userGroup);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("添加用户权限信息失败!");
        }
        if (!userGroupDataMapper.addUserIntoUserGroup(userGroup)) {
            log.warn("添加用户所属用户组信息失败!\n执行操作:添加用户所有信息\nuser:{},userPrivileges:{}，userGroup:{}",user,userPrivileges,userGroup);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("添加用户所属用户组信息失败!");
        }
        log.info("添加完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg addUserBaseInfo(User user) {
        log.info("即将开始添加用户基本信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if (!userBaseDataMapper.addUserIntoUserBaseData(user)) {
            log.warn("添加用户基本信息失败!\n执行操作:添加用户基本信息\nuser:{}",user);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("添加用户基本信息失败!");
        }
        log.info("添加完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg addUserPrivileges(UserPrivileges userPrivileges) {
        log.info("即将开始添加用户权限信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if (!userPrivilegesDataMapper.addUserIntoUserPrivilegesData(userPrivileges)) {
            log.warn("添加用户权限信息失败!\n执行操作:添加用户权限信息\nuserPrivileges:{}",userPrivileges);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("添加用户权限信息失败!");
        }
        log.info("添加完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg addUserGroup(UserGroup userGroup) {
        log.info("即将开始添加用户所属用户组信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if (!userGroupDataMapper.addUserIntoUserGroup(userGroup)) {
            log.warn("添加用户所属用户组信息失败!\n执行操作:添加用户所属用户组信息\nuserGroup:{}",userGroup);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("添加用户所属用户组信息失败!");
        }
        log.info("添加完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }


    @Override
    public UserDataReturnMsg deleteUserAllInfoByUid(String uid) {
        log.info("即将开始通过uid删除用户所有信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if (!userBaseDataMapper.deleteUserBaseDataByUid(uid)) {
            log.warn("删除用户基本信息失败!\n执行操作:通过uid删除用户所有信息\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("删除用户基本信息失败!");
        }
        if (!userPrivilegesDataMapper.deleteUserPrivilegesDataByUid(uid)) {
            log.warn("删除用户权限信息失败!\n执行操作:通过uid删除用户所有信息\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("删除用户权限信息失败!");
        }
        if (!userGroupDataMapper.deleteUserGroupDataByUid(uid)) {
            log.warn("删除用户所属用户组信息失败!\n执行操作:通过uid删除用户所有信息\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("删除用户所属用户组信息失败!");
        }
        log.info("删除完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg deleteUserAllInfoByEmail(String email) {
        log.info("即将开始通过email删除用户所有信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        if(userBaseDataByEmail==null){
            log.warn("用户基本信息查询失败!\n所在操作:通过email删除用户所有信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
            log.warn("删除失败!");
            returnMsg.setMsg(Msg);
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        if (!userBaseDataMapper.deleteUserBaseDataByUid(userBaseDataByEmail.getUid())) {
            log.warn("删除用户基本信息失败!\n执行操作:通过email删除用户所有信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("删除用户基本信息失败!");
        }
        if (!userPrivilegesDataMapper.deleteUserPrivilegesDataByUid(userBaseDataByEmail.getUid())) {
            log.warn("删除用户权限信息失败!\n执行操作:通过email删除用户所有信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("删除用户权限信息失败!");
        }
        if (!userGroupDataMapper.deleteUserGroupDataByUid(userBaseDataByEmail.getUid())) {
            log.warn("删除用户所属用户组信息失败!\n执行操作:通过email删除用户所有信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("删除用户所属用户组信息失败!");
        }
        log.info("删除完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg deleteUserBaseInfoByUid(String uid) {
        log.info("即将开始通过用户uid删除用户基本信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if (!userBaseDataMapper.deleteUserBaseDataByUid(uid)) {
            log.warn("删除用户基本信息失败!\n执行操作:通过用户uid删除用户基本信息\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("删除用户基本信息失败!");
        }
        log.info("删除完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg deleteUserBaseInfoByEmail(String email) {
        log.info("即将开始通过用户email删除用户基本信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        if(userBaseDataByEmail==null){
            log.warn("用户基本信息查询失败!\n所在操作:通过用户email删除用户基本信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
            log.warn("删除失败!");
            returnMsg.setMsg(Msg);
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        if (!userBaseDataMapper.deleteUserBaseDataByUid(userBaseDataByEmail.getUid())) {
            log.warn("删除用户基本信息失败!\n执行操作:通过用户uid删除用户基本信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("删除用户基本信息失败!");
        }
        log.info("删除完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg deleteUserPrivilegesByUid(String uid) {
        log.info("即将开始通过用户uid删除用户权限信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if (!userPrivilegesDataMapper.deleteUserPrivilegesDataByUid(uid)) {
            log.warn("删除用户权限信息失败!\n执行操作:通过email删除用户所有信息\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("删除用户权限信息失败!");
        }
        log.info("删除完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg deleteUserPrivilegesByEmail(String email) {
        log.info("即将开始通过用户email删除用户权限信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        if(userBaseDataByEmail==null){
            log.warn("用户基本信息查询失败!\n所在操作:通过用户email删除用户权限信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
            log.warn("删除失败!");
            returnMsg.setMsg(Msg);
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        if (!userPrivilegesDataMapper.deleteUserPrivilegesDataByUid(userBaseDataByEmail.getUid())) {
            log.warn("删除用户权限信息失败!\n执行操作:通过用户email删除用户权限信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户权限信息删除失败!");
        }
        log.info("删除完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg deleteUserGroupByUid(String uid) {
        log.info("即将开始通过用户uid删除用户所属用户组信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        if (!userGroupDataMapper.deleteUserGroupDataByUid(uid)) {
            log.warn("删除用户所属用户组信息失败!\n执行操作:通过用户uid删除用户所属用户组信息\nuid:{}",uid);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户信息删除失败!");
        }
        log.info("删除完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }

    @Override
    public UserDataReturnMsg deleteUserGroupByEmail(String email) {
        log.info("即将开始通过用户email删除用户所属用户组信息.");
        UserDataReturnMsg returnMsg = new UserDataReturnMsg();
        List<String> Msg = new ArrayList<>();
        User userBaseDataByEmail = userBaseDataMapper.findUserBaseDataByEmail(email);
        if(userBaseDataByEmail==null){
            log.warn("用户基本信息查询失败!\n所在操作:通过用户email删除用户所属用户组信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户基本信息查询失败!");
            log.warn("删除失败!");
            returnMsg.setMsg(Msg);
            log.info("本次业务执行完毕.");
            return returnMsg;
        }
        if (!userGroupDataMapper.deleteUserGroupDataByUid(userBaseDataByEmail.getUid())) {
            log.warn("删除用户所属用户组信息失败!\n执行操作:通过用户email删除用户所属用户组信息\nemail:{}",email);
            returnMsg.setStatus(ConstantPool.ERROR);
            Msg.add("用户所属用户组删除失败!");
        }
        log.info("删除完毕.");
        returnMsg.setMsg(Msg);
        return returnMsg;
    }
}
